home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 January: Mac OS SDK / Dev.CD Jan 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / AIncludes / OCE.a < prev    next >
Encoding:
Text File  |  1997-08-12  |  60.6 KB  |  1,949 lines  |  [TEXT/MPS ]

  1. ;
  2. ;    File:        OCE.a
  3. ;
  4. ;    Contains:    Apple Open Collaboration Environment (AOCE) Interfaces.
  5. ;
  6. ;    Version:    Technology:    AOCE Toolbox 1.02
  7. ;                Release:    Universal Interfaces 3.0.1
  8. ;
  9. ;    Copyright:    © 1994-1997 by Apple Computer, Inc., all rights reserved.
  10. ;
  11. ;    Bugs?:        Please include the the file and version information (from above) with
  12. ;                the problem description.  Developers belonging to one of the Apple
  13. ;                developer programs can submit bug reports to:
  14. ;
  15. ;                    devsupport@apple.com
  16. ;
  17. ;
  18.     IF &TYPE('__OCE__') = 'UNDEFINED' THEN
  19. __OCE__ SET 1
  20.  
  21.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  22.     include 'Types.a'
  23.     ENDIF
  24.     IF &TYPE('__ALIASES__') = 'UNDEFINED' THEN
  25.     include 'Aliases.a'
  26.     ENDIF
  27.     IF &TYPE('__APPLEEVENTS__') = 'UNDEFINED' THEN
  28.     include 'AppleEvents.a'
  29.     ENDIF
  30.  
  31. ;  All utility routines defined here are callable at interrupt level. 
  32. ; typedef unsigned short                 OCERecordTypeIndex
  33.  
  34. ; typedef unsigned short                 OCEAttributeTypeIndex
  35.  
  36. ;  For anyone who absolutely needs a define of the body of the standard record or
  37. ;attribute type, use these below.  CAUTION!  All the types below are assumed to be
  38. ;in character set 'smRoman'.  If you try to compare these to some RString or
  39. ;AttributeType variable, you must take the character set code into account.  Future
  40. ;standard types may be defined using character sets other than 'smRoman'. 
  41.  
  42.  
  43. ;  All these standard definitions begin with the Apple symbol (not shown here).
  44. ;
  45. ;NOTE:  To access these, you must call OCEGetIndRecordType or OCEGetIndAttributeType
  46. ;with the proper index.  These routines return pointers to the standard type.
  47. ;This was done so that code fragments (INITs, CDEVs, CSAMs, etc). which cannot
  48. ;use global data can also use these. 
  49.  
  50. ;  Indices for the standard definitions for certain record types (OCERecordTypeIndex): 
  51.  
  52. kUserRecTypeNum                    EQU        1                    ; "User" 
  53. kGroupRecTypeNum                EQU        2                    ; "Group" 
  54. kMnMRecTypeNum                    EQU        3                    ; "AppleMail™ M&M" 
  55. kMnMForwarderRecTypeNum            EQU        4                    ; "AppleMail™ Fwdr" 
  56. kNetworkSpecRecTypeNum            EQU        5                    ; "NetworkSpec" 
  57. kADAPServerRecTypeNum            EQU        6                    ; "ADAP Server" 
  58. kADAPDNodeRecTypeNum            EQU        7                    ; "ADAP DNode" 
  59. kADAPDNodeRepRecTypeNum            EQU        8                    ; "ADAP DNode Rep" 
  60. kServerSetupRecTypeNum            EQU        9                    ; "Server Setup" 
  61. kDirectoryRecTypeNum            EQU        10                    ; "Directory" 
  62. kDNodeRecTypeNum                EQU        11                    ; "DNode" 
  63. kSetupRecTypeNum                EQU        12                    ; "Setup" 
  64. kMSAMRecTypeNum                    EQU        13                    ; "MSAM" 
  65. kDSAMRecTypeNum                    EQU        14                    ; "DSAM" 
  66. kAttributeValueRecTypeNum        EQU        15                    ; "Attribute Value" 
  67. kBusinessCardRecTypeNum            EQU        16                    ; "Business Card" 
  68. kMailServiceRecTypeNum            EQU        17                    ; "Mail Service" 
  69. kCombinedRecTypeNum                EQU        18                    ; "Combined" 
  70. kOtherServiceRecTypeNum            EQU        19                    ; "Other Service" 
  71. kAFPServiceRecTypeNum            EQU        20                    ; "Other Service afps" 
  72. kFirstOCERecTypeNum                EQU        1                    ; first standard OCE record type 
  73. kLastOCERecTypeNum                EQU        20                    ; last standard OCE record type 
  74. kNumOCERecTypes                    EQU        20
  75. ;  Indices for the standard definitions for certain attribute types (OCEAttributeTypeIndex): 
  76.  
  77. kMemberAttrTypeNum                EQU        1001                ; "Member" 
  78. kAdminsAttrTypeNum                EQU        1002                ; "Administrators" 
  79. kMailSlotsAttrTypeNum            EQU        1003                ; "mailslots" 
  80. kPrefMailAttrTypeNum            EQU        1004                ; "pref mailslot" 
  81. kAddressAttrTypeNum                EQU        1005                ; "Address" 
  82. kPictureAttrTypeNum                EQU        1006                ; "Picture" 
  83. kAuthKeyAttrTypeNum                EQU        1007                ; "auth key" 
  84. kTelephoneAttrTypeNum            EQU        1008                ; "Telephone" 
  85. kNBPNameAttrTypeNum                EQU        1009                ; "NBP Name" 
  86. kQMappingAttrTypeNum            EQU        1010                ; "ForwarderQMap" 
  87. kDialupSlotAttrTypeNum            EQU        1011                ; "DialupSlotInfo" 
  88. kHomeNetAttrTypeNum                EQU        1012                ; "Home Internet" 
  89. kCoResAttrTypeNum                EQU        1013                ; "Co-resident M&M" 
  90. kFwdrLocalAttrTypeNum            EQU        1014                ; "FwdrLocalRecord" 
  91. kConnectAttrTypeNum                EQU        1015                ; "Connected To" 
  92. kForeignAttrTypeNum                EQU        1016                ; "Foreign RLIs" 
  93. kOwnersAttrTypeNum                EQU        1017                ; "Owners" 
  94. kReadListAttrTypeNum            EQU        1018                ; "ReadList" 
  95. kWriteListAttrTypeNum            EQU        1019                ; "WriteList" 
  96. kDescriptorAttrTypeNum            EQU        1020                ; "Descriptor" 
  97. kCertificateAttrTypeNum            EQU        1021                ; "Certificate" 
  98. kMsgQsAttrTypeNum                EQU        1022                ; "MessageQs" 
  99. kPrefMsgQAttrTypeNum            EQU        1023                ; "PrefMessageQ" 
  100. kMasterPFAttrTypeNum            EQU        1024                ; "MasterPF" 
  101. kMasterNetSpecAttrTypeNum        EQU        1025                ; "MasterNetSpec" 
  102. kServersOfAttrTypeNum            EQU        1026                ; "Servers Of" 
  103. kParentCIDAttrTypeNum            EQU        1027                ; "Parent CID" 
  104. kNetworkSpecAttrTypeNum            EQU        1028                ; "NetworkSpec" 
  105. kLocationAttrTypeNum            EQU        1029                ; "Location" 
  106. kTimeSvrTypeAttrTypeNum            EQU        1030                ; "TimeServer Type" 
  107. kUpdateTimerAttrTypeNum            EQU        1031                ; "Update Timer" 
  108. kShadowsOfAttrTypeNum            EQU        1032                ; "Shadows Of" 
  109. kShadowServerAttrTypeNum        EQU        1033                ; "Shadow Server" 
  110. kTBSetupAttrTypeNum                EQU        1034                ; "TB Setup" 
  111. kMailSetupAttrTypeNum            EQU        1035                ; "Mail Setup" 
  112. kSlotIDAttrTypeNum                EQU        1036                ; "SlotID" 
  113. kGatewayFileIDAttrTypeNum        EQU        1037                ; "Gateway FileID" 
  114. kMailServiceAttrTypeNum            EQU        1038                ; "Mail Service" 
  115. kStdSlotInfoAttrTypeNum            EQU        1039                ; "Std Slot Info" 
  116. kAssoDirectoryAttrTypeNum        EQU        1040                ; "Asso. Directory" 
  117. kDirectoryAttrTypeNum            EQU        1041                ; "Directory" 
  118. kDirectoriesAttrTypeNum            EQU        1042                ; "Directories" 
  119. kSFlagsAttrTypeNum                EQU        1043                ; "SFlags" 
  120. kLocalNameAttrTypeNum            EQU        1044                ; "Local Name" 
  121. kLocalKeyAttrTypeNum            EQU        1045                ; "Local Key" 
  122. kDirUserRIDAttrTypeNum            EQU        1046                ; "Dir User RID" 
  123. kDirUserKeyAttrTypeNum            EQU        1047                ; "Dir User Key" 
  124. kDirNativeNameAttrTypeNum        EQU        1048                ; "Dir Native Name" 
  125. kCommentAttrTypeNum                EQU        1049                ; "Comment" 
  126. kRealNameAttrTypeNum            EQU        1050                ; "Real Name" 
  127. kPrivateDataAttrTypeNum            EQU        1051                ; "Private Data" 
  128. kDirTypeAttrTypeNum                EQU        1052                ; "Directory Type" 
  129. kDSAMFileAliasAttrTypeNum        EQU        1053                ; "DSAM File Alias" 
  130. kCanAddressToAttrTypeNum        EQU        1054                ; "Can Address To" 
  131. kDiscriminatorAttrTypeNum        EQU        1055                ; "Discriminator" 
  132. kAliasAttrTypeNum                EQU        1056                ; "Alias" 
  133. kParentMSAMAttrTypeNum            EQU        1057                ; "Parent MSAM" 
  134. kParentDSAMAttrTypeNum            EQU        1058                ; "Parent DSAM" 
  135. kSlotAttrTypeNum                EQU        1059                ; "Slot" 
  136. kAssoMailServiceAttrTypeNum        EQU        1060                ; "Asso. Mail Service" 
  137. kFakeAttrTypeNum                EQU        1061                ; "Fake" 
  138. kInheritSysAdminAttrTypeNum        EQU        1062                ; "Inherit SysAdministrators" 
  139. kPreferredPDAttrTypeNum            EQU        1063                ; "Preferred PD" 
  140. kLastLoginAttrTypeNum            EQU        1064                ; "Last Login" 
  141. kMailerAOMStateAttrTypeNum        EQU        1065                ; "Mailer AOM State" 
  142. kMailerSendOptionsAttrTypeNum    EQU        1066                ; "Mailer Send Options" 
  143. kJoinedAttrTypeNum                EQU        1067                ; "Joined" 
  144. kUnconfiguredAttrTypeNum        EQU        1068                ; "Unconfigured" 
  145. kVersionAttrTypeNum                EQU        1069                ; "Version" 
  146. kLocationNamesAttrTypeNum        EQU        1070                ; "Location Names" 
  147. kActiveAttrTypeNum                EQU        1071                ; "Active" 
  148. kDeleteRequestedAttrTypeNum        EQU        1072                ; "Delete Requested" 
  149. kGatewayTypeAttrTypeNum            EQU        1073                ; "Gateway Type" 
  150. kFirstOCEAttrTypeNum            EQU        1001                ; first standard OCE attr type 
  151. kLastOCEAttrTypeNum                EQU        1073                ; last standard OCE attr type 
  152. kNumOCEAttrTypes                EQU        73
  153.  
  154. ;  Miscellaneous enums: 
  155.  
  156. kRString32Size                    EQU        32                    ; max size of the body field in RString32 
  157. kRString64Size                    EQU        64                    ; max size of the body field in RString64 
  158. kNetworkSpecMaxBytes            EQU        32                    ; max size of the body field in NetworkSpec 
  159. kPathNameMaxBytes                EQU        1024                ; max size of the data field in PackedPathName 
  160. kDirectoryNameMaxBytes            EQU        32                    ; max size of the body field in DirectoryName 
  161. kAttributeTypeMaxBytes            EQU        32                    ; max size of the body field in AttributeType 
  162. kAttrValueMaxBytes                EQU        65536                ; max size of any attribute value 
  163. kRStringMaxBytes                EQU        256                    ; max size (in bytes) of the body field of a recordName or recordType 
  164. kRStringMaxChars                EQU        128                    ; max size (in chars) of the body field of a recordName or recordType 
  165.  
  166. kNULLDNodeNumber                EQU        0                    ; Special value meaning none specified 
  167. kRootDNodeNumber                EQU        2                    ; DNodeNum corresponding to the root of the tree 
  168.  
  169. ;  This enum is used to select the kind of RString in calls such as OCERelRString,
  170. ;OCEEqualRString, and OCEValidRString.
  171. ;
  172. ;eGenericSensitive and eGenericInsensitive are enumerators that can be used if you
  173. ;use RStrings for things other than what you see in this file.  If you want them to
  174. ;be compared in a case- and diacritical-sensitive manner (c ≠ C ≠ ç), use
  175. ;eGenericSensitive.  If you want them to be compared in a case- and diacritical-
  176. ;insensitive manner (c = C = ç), use eGenericInensitive.
  177. ;WARNING:  do not use eGenericSensitive and eGenericInsensitive with catalog
  178. ;names, entity names, pathname parts, entity types, network specs, or attribute
  179. ;types!  Don't assume that you know how they should be compared!!! 
  180.  
  181.  
  182. kOCEDirName                        EQU        0
  183. kOCERecordOrDNodeName            EQU        1
  184. kOCERecordType                    EQU        2
  185. kOCENetworkSpec                    EQU        3
  186. kOCEAttrType                    EQU        4
  187. kOCEGenericSensitive            EQU        5
  188. kOCEGenericInsensitive            EQU        6
  189. ; typedef unsigned short                 RStringKind
  190.  
  191. ;  Values for the signature field in Discriminator 
  192.  
  193. kDirAllKinds                    EQU        0
  194. kDirADAPKind                    EQU        'adap'
  195. kDirPersonalDirectoryKind        EQU        'pdir'
  196. kDirDSAMKind                    EQU        'dsam'
  197.  
  198. ; typedef unsigned long                 OCEDirectoryKind
  199.  
  200. ;  Values returned by GetDSSpecInfo() 
  201.  
  202. kOCEInvalidDSSpec                EQU        $3F3F3F3F            ; '????' could not be determined 
  203. kOCEDirsRootDSSpec                EQU        'root'                ; root of all catalogs ("Catalogs" icon) 
  204. kOCEDirectoryDSSpec                EQU        'dire'                ; catalog 
  205. kOCEDNodeDSSpec                    EQU        'dnod'                ; d-node 
  206. kOCERecordDSSpec                EQU        'reco'                ; record 
  207. kOCEentnDSSpec                    EQU        'entn'                ; extensionType is 'entn' 
  208. kOCENOTentnDSSpec                EQU        'not '                ; extensionType is not 'entn' 
  209.  
  210. ;  Values for AttributeTag 
  211.  
  212. typeRString                        EQU        'rstr'
  213. typePackedDSSpec                EQU        'dspc'
  214. typeBinary                        EQU        'bnry'
  215.  
  216. ;  Bit flag corresponding to the canContainRecords bit.  Use it like this:
  217. ;    if (foo & kCanContainRecords)
  218. ;        then this dNode can contain records!
  219. ;kForeignNode is used to indicate nodes in the name hierarchy that correspond to
  220. ;foreign catalogs (meaning ADAP sees no clusters or DNodes beneath it, but
  221. ;mail routers might be able to route to clusters beneath it. 
  222.  
  223.  
  224. kCanContainRecordsBit            EQU        0
  225. kForeignNodeBit                    EQU        1
  226. ;  DirNodeKind 
  227.  
  228. kCanContainRecords                EQU        $00000001
  229. kForeignNode                    EQU        $00000002
  230. ; typedef unsigned long                 DirNodeKind
  231.  
  232.  
  233.  
  234. ; *** Toolbox Control ***
  235. ;  We will have a version number and attributes for toolboxes off the aa5e trap
  236. ;and the S&F server trap.
  237. ;
  238. ;This includes the OCE toolbox and S&F Server.  [Note: the S&F server will
  239. ;change to ONLY service ServerGateway calls —it will then be necessary to run
  240. ;it co–resident with an OCE toolbox].
  241. ;
  242. ;The high order word will represent the S&F Server version number.  The low
  243. ;order word will represent the OCE toolbox version number.  These will be zero
  244. ;until the component is up and running.  It is not possible to know these
  245. ;a–priori. Note: there will not be a seperate version numbers for each component
  246. ;in the OCE toolbox or S&F server.
  247. ;
  248. ;The above is consistent with the standard System 7.0 usage of Gestalt.
  249. ;
  250. ;The oce tb attribute gestaltOCETBPresent implies the existence of OCE on a
  251. ;machine.
  252. ;
  253. ;The OCE TB attribute gestaltOCETBAvailable implies the availablity of OCE calls.
  254. ;
  255. ;The attribute gestaltOCESFServerAvailable implies the availablity of OCE calls
  256. ;available through the S&F server. This are essentially the server gateway calls.
  257. ;
  258. ;Any (future) remaining OCE attributes may not be established correctly until
  259. ;the attribute gestaltOCETBAvailable is set.
  260. ;
  261. ;
  262.  
  263.  
  264. ;     Constants used for Transitions. 
  265.  
  266. ATTransIPMStart                    EQU        'ipms'
  267. ATTransIPMShutdown                EQU        'ipmd'
  268. ATTransDirStart                    EQU        'dirs'
  269. ATTransDirShutdown                EQU        'dird'
  270. ATTransAuthStart                EQU        'auts'
  271. ATTransAuthShutdown                EQU        'autd'
  272. ATTransSFStart                    EQU        's&fs'
  273. ATTransSFShutdown                EQU        's&fd'
  274.  
  275.  
  276. ;  Some definitions for time-related parameters: 
  277. ;  Interpreted as UTC seconds since 1/1/1904 
  278. ; typedef unsigned long                 UTCTime
  279.  
  280. ;  seconds EAST of Greenwich 
  281. ; typedef long                             UTCOffset
  282.  
  283. ;  This is the same as the ScriptManager script. 
  284. ; typedef short                         CharacterSet
  285.  
  286. ; *** RString ***
  287.  
  288. ;  struct RString is a maximum-sized structure.  Allocate one of these and it will
  289. ;hold any valid RString. 
  290. RString                    RECORD 0
  291. charSet                     ds.w    1                ; offset: $0 (0)
  292. dataLength                 ds.w    1                ; offset: $2 (2)
  293. body                     ds.b    256                ; offset: $4 (4)        ;  place for characters 
  294. sizeof                     EQU *                    ; size:   $104 (260)
  295.                         ENDR
  296. ;  struct ProtoRString is a minimum-sized structure.  Use this for a variable-length RString. 
  297. ProtoRString            RECORD 0
  298. charSet                     ds.w    1                ; offset: $0 (0)
  299. dataLength                 ds.w    1                ; offset: $2 (2)
  300. sizeof                     EQU *                    ; size:   $4 (4)
  301.                         ENDR
  302. ; typedef struct RString *                RStringPtr
  303.  
  304. ; typedef RStringPtr *                    RStringHandle
  305.  
  306. ; typedef struct ProtoRString *            ProtoRStringPtr
  307.  
  308. RString64                RECORD 0
  309. charSet                     ds.w    1                ; offset: $0 (0)
  310. dataLength                 ds.w    1                ; offset: $2 (2)
  311. body                     ds.b    64                ; offset: $4 (4)
  312. sizeof                     EQU *                    ; size:   $44 (68)
  313.                         ENDR
  314. RString32                RECORD 0
  315. charSet                     ds.w    1                ; offset: $0 (0)
  316. dataLength                 ds.w    1                ; offset: $2 (2)
  317. body                     ds.b    32                ; offset: $4 (4)
  318. sizeof                     EQU *                    ; size:   $24 (36)
  319.                         ENDR
  320. ;  Standard definitions for the entity type field and attribute type
  321. ;have been moved to the end of the file. 
  322.  
  323. ;  Copies str1 to str2.  str2Length is the size of str2, excluding header.
  324. ;A memFull error will be returned if that is not as large as str1->dataLength. 
  325. ;
  326. ; pascal OSErr OCECopyRString(const RString *str1, RString *str2, unsigned short str2Length)
  327. ;
  328.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  329.         Macro
  330.         _OCECopyRString
  331.             move.w              #$0308,D0
  332.             dc.w                $AA5C
  333.         EndM
  334.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  335.         IMPORT_CFM_FUNCTION OCECopyRString
  336.     ENDIF
  337.  
  338.  
  339. ;     Make an RString from a C string.  If the c string is bigger than rStrLength,
  340. ;only rStrLength bytes will be copied. (rStrLength does not include the header size) 
  341. ;
  342. ; pascal void OCECToRString(const char *cStr, CharacterSet charSet, RString *rStr, unsigned short rStrLength)
  343. ;
  344.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  345.         Macro
  346.         _OCECToRString
  347.             move.w              #$0339,D0
  348.             dc.w                $AA5C
  349.         EndM
  350.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  351.         IMPORT_CFM_FUNCTION OCECToRString
  352.     ENDIF
  353.  
  354.  
  355. ;     Make an RString from a Pascal string.  If the Pascal string is bigger than rStrLength,
  356. ;only rStrLength bytes will be copied. (rStrLength does not include the header size) 
  357. ;
  358. ; pascal void OCEPToRString(ConstStr255Param pStr, CharacterSet charSet, RString *rStr, unsigned short rStrLength)
  359. ;
  360.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  361.         Macro
  362.         _OCEPToRString
  363.             move.w              #$033A,D0
  364.             dc.w                $AA5C
  365.         EndM
  366.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  367.         IMPORT_CFM_FUNCTION OCEPToRString
  368.     ENDIF
  369.  
  370.  
  371. ;     Make a Pascal string from an RString.  It's up to you to check the char set of
  372. ;the RString, or if the length of the RString is greater than 255 (the Pascal string's
  373. ;length will simply be the lower byte of the RString's length).  The StringPtr that is
  374. ;returned will point directly into the RString (no memory will be allocated). 
  375.  
  376. ;
  377. ; pascal StringPtr OCERToPString(const RString *rStr)
  378. ;
  379.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  380.         Macro
  381.         _OCERToPString
  382.             move.w              #$033B,D0
  383.             dc.w                $AA5C
  384.         EndM
  385.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  386.         IMPORT_CFM_FUNCTION OCERToPString
  387.     ENDIF
  388.  
  389. ;     Check the relative equality of two RStrings.  Determines if str1 is greater than,
  390. ;equal to, or less than str2.  Result types for OCERelRString are defined in <OSUtils.h>
  391. ;(same as for RelString). 
  392.  
  393. ;
  394. ; pascal short OCERelRString(const void *str1, const void *str2, RStringKind kind)
  395. ;
  396.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  397.         Macro
  398.         _OCERelRString
  399.             move.w              #$032D,D0
  400.             dc.w                $AA5C
  401.         EndM
  402.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  403.         IMPORT_CFM_FUNCTION OCERelRString
  404.     ENDIF
  405.  
  406.  
  407. ;     Check for equality of two RStrings. Returns true if equal. 
  408. ;
  409. ; pascal Boolean OCEEqualRString(const void *str1, const void *str2, RStringKind kind)
  410. ;
  411.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  412.         Macro
  413.         _OCEEqualRString
  414.             move.w              #$0316,D0
  415.             dc.w                $AA5C
  416.         EndM
  417.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  418.         IMPORT_CFM_FUNCTION OCEEqualRString
  419.     ENDIF
  420.  
  421.  
  422. ;     Check the validity of an RString.  Returns true if the RString is valid 
  423. ;
  424. ; pascal Boolean OCEValidRString(const void *str, RStringKind kind)
  425. ;
  426.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  427.         Macro
  428.         _OCEValidRString
  429.             move.w              #$0338,D0
  430.             dc.w                $AA5C
  431.         EndM
  432.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  433.         IMPORT_CFM_FUNCTION OCEValidRString
  434.     ENDIF
  435.  
  436.  
  437. ; *** CreationID ***
  438. CreationID                RECORD 0
  439. source                     ds.l    1                ; offset: $0 (0)        ;  Fields definitions and usage are not defined 
  440. seq                         ds.l    1                ; offset: $4 (4)
  441. sizeof                     EQU *                    ; size:   $8 (8)
  442.                         ENDR
  443. AttributeCreationID        RECORD 0
  444. f                         ds        CreationID
  445. sizeof                     EQU *                    ; size:   $8 (8)
  446.                         ENDR
  447.  
  448.  
  449. ; typedef struct CreationID *            CreationIDPtr
  450.  
  451.  
  452. ;  Returns a pointer to a null CreationID . 
  453. ;
  454. ; pascal const CreationID *OCENullCID(void )
  455. ;
  456.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  457.         Macro
  458.         _OCENullCID
  459.             move.w              #$0344,D0
  460.             dc.w                $AA5C
  461.         EndM
  462.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  463.         IMPORT_CFM_FUNCTION OCENullCID
  464.     ENDIF
  465.  
  466.  
  467. ;  Returns a pointer to a special CreationID used within the PathFinder. 
  468. ;
  469. ; pascal const CreationID *OCEPathFinderCID(void )
  470. ;
  471.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  472.         Macro
  473.         _OCEPathFinderCID
  474.             move.w              #$033C,D0
  475.             dc.w                $AA5C
  476.         EndM
  477.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  478.         IMPORT_CFM_FUNCTION OCEPathFinderCID
  479.     ENDIF
  480.  
  481.  
  482. ;  Sets the CreationID to a null value. 
  483. ;
  484. ; pascal void OCESetCreationIDtoNull(CreationID *cid)
  485. ;
  486.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  487.         Macro
  488.         _OCESetCreationIDtoNull
  489.             move.w              #$032E,D0
  490.             dc.w                $AA5C
  491.         EndM
  492.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  493.         IMPORT_CFM_FUNCTION OCESetCreationIDtoNull
  494.     ENDIF
  495.  
  496.  
  497. ;  Copies the value of cid1 to cid2. 
  498. ;
  499. ; pascal void OCECopyCreationID(const CreationID *cid1, CreationID *cid2)
  500. ;
  501.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  502.         Macro
  503.         _OCECopyCreationID
  504.             move.w              #$0300,D0
  505.             dc.w                $AA5C
  506.         EndM
  507.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  508.         IMPORT_CFM_FUNCTION OCECopyCreationID
  509.     ENDIF
  510.  
  511.  
  512. ;  Check the equality of two CreationIDs. 
  513. ;
  514. ; pascal Boolean OCEEqualCreationID(const CreationID *cid1, const CreationID *cid2)
  515. ;
  516.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  517.         Macro
  518.         _OCEEqualCreationID
  519.             move.w              #$030C,D0
  520.             dc.w                $AA5C
  521.         EndM
  522.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  523.         IMPORT_CFM_FUNCTION OCEEqualCreationID
  524.     ENDIF
  525.  
  526.  
  527. ; *** NetworkSpec ***
  528. ;  For the record, a NetworkSpec is an RString with a smaller maximum size.
  529. ;I don't just typedef it to an RString, because I want the definition of the NetworkSpec
  530. ;struct to contain the max length.  But it should be possible to typecast any
  531. ;NetworkSpec to an RString and use all the RString utilities on it. 
  532.  
  533. NetworkSpec                RECORD 0
  534. charSet                     ds.w    1                ; offset: $0 (0)
  535. dataLength                 ds.w    1                ; offset: $2 (2)
  536. body                     ds.b    32                ; offset: $4 (4)        ;  always fixed at the max size 
  537. sizeof                     EQU *                    ; size:   $24 (36)
  538.                         ENDR
  539. ; typedef struct NetworkSpec *            NetworkSpecPtr
  540.  
  541.  
  542. ; *** PackedPathName ***
  543. ;  struct PackedPathName is a maximum-sized structure.  Allocate one of
  544. ;these and it will hold any valid packed pathname. 
  545. PackedPathName            RECORD 0
  546. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  547. data                     ds.b    1022            ; offset: $2 (2)
  548. sizeof                     EQU *                    ; size:   $400 (1024)
  549.                         ENDR
  550. ;  struct ProtoPackedPathName is a minimum-sized structure.  Use this
  551. ;for a variable-length packed PathName. 
  552. ProtoPackedPathName        RECORD 0
  553. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  554. ;  Followed by data 
  555. sizeof                     EQU *                    ; size:   $2 (2)
  556.                         ENDR
  557. ; typedef struct PackedPathName *        PackedPathNamePtr
  558.  
  559. ; typedef struct ProtoPackedPathName *    ProtoPackedPathNamePtr
  560.  
  561. ;Copy the contents of path1 to path2.  path2Length is the size of path2, and must
  562. ;be large enough to hold a copy of path1.  A memFull error will be returned if that
  563. ;is not the case.
  564. ;
  565.  
  566. ;
  567. ; pascal OSErr OCECopyPackedPathName(const PackedPathName *path1, PackedPathName *path2, unsigned short path2Length)
  568. ;
  569.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  570.         Macro
  571.         _OCECopyPackedPathName
  572.             move.w              #$0304,D0
  573.             dc.w                $AA5C
  574.         EndM
  575.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  576.         IMPORT_CFM_FUNCTION OCECopyPackedPathName
  577.     ENDIF
  578.  
  579.  
  580. ;Returns true if packed path pointer is nil, or is of zero length, or is of
  581. ;length 2 and nParts of zero.
  582. ;
  583.  
  584. ;
  585. ; pascal Boolean OCEIsNullPackedPathName(const PackedPathName *path)
  586. ;
  587.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  588.         Macro
  589.         _OCEIsNullPackedPathName
  590.             move.w              #$031D,D0
  591.             dc.w                $AA5C
  592.         EndM
  593.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  594.         IMPORT_CFM_FUNCTION OCEIsNullPackedPathName
  595.     ENDIF
  596.  
  597.  
  598. ;OCEUnpackPathName breaks apart the path into its component RStrings, writing string
  599. ;pointers into the array 'parts', which the client asserts can hold as many as
  600. ;'nParts' elements. The number of parts actually found is returned.  Strings are
  601. ;placed in the array in order from lowest to highest.  The first pathName element
  602. ;beneath the root appears last.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO
  603. ;THE PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  604. ;WITH THE UNPACKED STRUCT AS WELL
  605. ;
  606.  
  607. ;
  608. ; pascal unsigned short OCEUnpackPathName(const PackedPathName *path, RStringPtr *parts, unsigned short nParts)
  609. ;
  610.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  611.         Macro
  612.         _OCEUnpackPathName
  613.             move.w              #$0330,D0
  614.             dc.w                $AA5C
  615.         EndM
  616.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  617.         IMPORT_CFM_FUNCTION OCEUnpackPathName
  618.     ENDIF
  619.  
  620. ;OCEPackedPathNameSize computes the number of bytes of memory needed to hold a
  621. ;PackedPathName manufactured from the array of parts.  This length
  622. ;includes the length of the length field of PackedPathName, so it
  623. ;is safe to do a NewPtr (OCEPackedPathNameSize(...)).
  624. ;
  625.  
  626. ;
  627. ; pascal unsigned short OCEPackedPathNameSize(const RStringPtr *parts, unsigned short nParts)
  628. ;
  629.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  630.         Macro
  631.         _OCEPackedPathNameSize
  632.             move.w              #$0328,D0
  633.             dc.w                $AA5C
  634.         EndM
  635.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  636.         IMPORT_CFM_FUNCTION OCEPackedPathNameSize
  637.     ENDIF
  638.  
  639. ;  OCEDNodeNameCount returns the number of RStrings contained within the path. 
  640. ;
  641. ; pascal unsigned short OCEDNodeNameCount(const PackedPathName *path)
  642. ;
  643.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  644.         Macro
  645.         _OCEDNodeNameCount
  646.             move.w              #$032C,D0
  647.             dc.w                $AA5C
  648.         EndM
  649.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  650.         IMPORT_CFM_FUNCTION OCEDNodeNameCount
  651.     ENDIF
  652.  
  653.  
  654. ;OCEPackPathName packs the parts into the storage provided as 'path'.  path must be
  655. ;large enough to hold the packed pathname.  A memFull error will be returned if
  656. ;pathLength is too small.  parts[0] should contain the deepest pathName element,
  657. ;and parts[nParts - 1] should contain the name of the first pathName element beneath
  658. ;the root. 
  659. ;
  660.  
  661. ;
  662. ; pascal OSErr OCEPackPathName(RStringPtr *parts, unsigned short nParts, PackedPathName *path, unsigned short pathLength)
  663. ;
  664.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  665.         Macro
  666.         _OCEPackPathName
  667.             move.w              #$0323,D0
  668.             dc.w                $AA5C
  669.         EndM
  670.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  671.         IMPORT_CFM_FUNCTION OCEPackPathName
  672.     ENDIF
  673.  
  674. ;Check the equality of two packed paths.
  675. ;
  676.  
  677. ;
  678. ; pascal Boolean OCEEqualPackedPathName(const PackedPathName *path1, const PackedPathName *path2)
  679. ;
  680.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  681.         Macro
  682.         _OCEEqualPackedPathName
  683.             move.w              #$0311,D0
  684.             dc.w                $AA5C
  685.         EndM
  686.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  687.         IMPORT_CFM_FUNCTION OCEEqualPackedPathName
  688.     ENDIF
  689.  
  690.  
  691. ;OCEValidPackedPathName checks that the packed PathName is internally consistent.
  692. ;Returns true if it's ok.
  693. ;
  694.  
  695. ;
  696. ; pascal Boolean OCEValidPackedPathName(const PackedPathName *path)
  697. ;
  698.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  699.         Macro
  700.         _OCEValidPackedPathName
  701.             move.w              #$0334,D0
  702.             dc.w                $AA5C
  703.         EndM
  704.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  705.         IMPORT_CFM_FUNCTION OCEValidPackedPathName
  706.     ENDIF
  707.  
  708.  
  709. ; *** DirDiscriminator ***
  710. DirDiscriminator        RECORD 0
  711. signature                 ds.l    1                ; offset: $0 (0)
  712. misc                     ds.l    1                ; offset: $4 (4)
  713. sizeof                     EQU *                    ; size:   $8 (8)
  714.                         ENDR
  715. ;  Copies the value of disc1 to disc2. 
  716. ;
  717. ; pascal void OCECopyDirDiscriminator(const DirDiscriminator *disc1, DirDiscriminator *disc2)
  718. ;
  719.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  720.         Macro
  721.         _OCECopyDirDiscriminator
  722.             move.w              #$0301,D0
  723.             dc.w                $AA5C
  724.         EndM
  725.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  726.         IMPORT_CFM_FUNCTION OCECopyDirDiscriminator
  727.     ENDIF
  728.  
  729.  
  730. ;  Check the equality of two DirDiscriminators. 
  731. ;
  732. ; pascal Boolean OCEEqualDirDiscriminator(const DirDiscriminator *disc1, const DirDiscriminator *disc2)
  733. ;
  734.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  735.         Macro
  736.         _OCEEqualDirDiscriminator
  737.             move.w              #$030D,D0
  738.             dc.w                $AA5C
  739.         EndM
  740.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  741.         IMPORT_CFM_FUNCTION OCEEqualDirDiscriminator
  742.     ENDIF
  743.  
  744. ;This structure is called RLI because it really contains all the info you
  745. ;need to locate a record within the entire name space.  It contains four fields.
  746. ;The first two are the name of the catalog and a catalog discriminator.  These
  747. ;two fields are used to indicate to which catalog a given record belongs.  The
  748. ;discriminator is used to distinguish between two different catalogs that have
  749. ;the same name.
  750. ;
  751. ;The other two fields in the RLI structure are used to indicate a particular
  752. ;catalog node within the catalog specified by the directoryName and
  753. ;discriminator fields.  These fields are exactly analagous to the dirID and
  754. ;pathname used in HFS.  It is possible to specify a dNode just by dNodeNumber
  755. ;(pathname is nil), or just by pathname (dNodeNumber is set to kNULLDNodeNumber),
  756. ;or by a combination of the two.  The latter is called a 'partial pathname', and
  757. ;while it is valid in the Catalog Manager API, it is not supported by ADAP
  758. ;catalogs in Release 1.
  759. ;
  760. ;Note that the path parameter does not include the catalog name, but holds
  761. ;the names of all the nodes on the path to the desired catalog node, starting
  762. ;with the catalog node and working its way up the tree.
  763. ;
  764.  
  765.  
  766. ; *** RLI ***
  767.  
  768. DirectoryName            RECORD 0
  769. charSet                     ds.w    1                ; offset: $0 (0)
  770. dataLength                 ds.w    1                ; offset: $2 (2)
  771. body                     ds.b    32                ; offset: $4 (4)        ;  space for catalog name 
  772. sizeof                     EQU *                    ; size:   $24 (36)
  773.                         ENDR
  774. ; typedef struct DirectoryName *        DirectoryNamePtr
  775.  
  776. ;  Catalog node number 
  777. ; typedef unsigned long                 DNodeNum
  778.  
  779. RLI                        RECORD 0
  780. directoryName             ds.l    1                ; offset: $0 (0)        ;  pointer to the name of the catalog root 
  781. discriminator             ds        DirDiscriminator ; offset: $4 (4)        ;  used to discriminate between dup catalog names 
  782. dNodeNumber                 ds.l    1                ; offset: $C (12)        ;  number of the node 
  783. path                     ds.l    1                ; offset: $10 (16)        ;  old-style RLI 
  784. sizeof                     EQU *                    ; size:   $14 (20)
  785.                         ENDR
  786. ; typedef struct RLI *                    RLIPtr
  787.  
  788. ;Create a new RLI from the catalog name, discriminator, DNode number, and
  789. ;PackedPathName.  You must allocate the storage for the RLI and pass in a pointer
  790. ;to it.
  791. ;
  792.  
  793. ;
  794. ; pascal void OCENewRLI(RLI *newRLI, const DirectoryName *dirName, DirDiscriminator *discriminator, DNodeNum dNodeNumber, const PackedPathName *path)
  795. ;
  796.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  797.         Macro
  798.         _OCENewRLI
  799.             move.w              #$031F,D0
  800.             dc.w                $AA5C
  801.         EndM
  802.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  803.         IMPORT_CFM_FUNCTION OCENewRLI
  804.     ENDIF
  805.  
  806.  
  807. ;Duplicate the contents of rli1 to rli2.  No errors are returned. This
  808. ;simply copies the pointers to the catalog name and path, wiping out any pointer
  809. ;that you might have had in there.
  810. ;
  811.  
  812. ;
  813. ; pascal void OCEDuplicateRLI(const RLI *rli1, RLI *rli2)
  814. ;
  815.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  816.         Macro
  817.         _OCEDuplicateRLI
  818.             move.w              #$030B,D0
  819.             dc.w                $AA5C
  820.         EndM
  821.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  822.         IMPORT_CFM_FUNCTION OCEDuplicateRLI
  823.     ENDIF
  824.  
  825.  
  826. ;Copy the contents of rli1 to rli2.  rli2 must already contain
  827. ;pointers to structures large enough to hold copies of the corresponding
  828. ;fields from rli1.  A memFull error will be returned if that is not the case.
  829. ;So if you allocate a brand new empty destination, you must at least set up
  830. ;its length fields.
  831. ;
  832.  
  833. ;
  834. ; pascal OSErr OCECopyRLI(const RLI *rli1, RLI *rli2)
  835. ;
  836.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  837.         Macro
  838.         _OCECopyRLI
  839.             move.w              #$0307,D0
  840.             dc.w                $AA5C
  841.         EndM
  842.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  843.         IMPORT_CFM_FUNCTION OCECopyRLI
  844.     ENDIF
  845.  
  846.  
  847. ;Check the equality of two RLIs.  This will take into account differences
  848. ;in the case and diacriticals of the directoryName and the PathName.
  849. ;NOTE THAT THIS WILL FAIL IF rli1 CONTAINS A DNODENUMBER AND A NIL PATHNAME,
  850. ;AND rli2 CONTAINS kNULLDNodeNumber AND A NON-NIL PATHNAME.  IN OTHER WORDS,
  851. ;THE TWO rlis MUST BE OF THE SAME FORM TO CHECK FOR EQUALITY.
  852. ;The one exception is that if the pathname is nil, a dNodeNumber of zero and
  853. ;kRootDNodeNumber will be treated as equal.
  854. ;
  855.  
  856. ;
  857. ; pascal Boolean OCEEqualRLI(const RLI *rli1, const RLI *rli2)
  858. ;
  859.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  860.         Macro
  861.         _OCEEqualRLI
  862.             move.w              #$0315,D0
  863.             dc.w                $AA5C
  864.         EndM
  865.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  866.         IMPORT_CFM_FUNCTION OCEEqualRLI
  867.     ENDIF
  868.  
  869.  
  870. ;Check the validity of an RLI.  This checks that the catalog name length
  871. ;is within bounds, and the packed pathname (if specified) is valid.
  872. ;
  873.  
  874. ;
  875. ; pascal Boolean OCEValidRLI(const RLI *theRLI)
  876. ;
  877.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  878.         Macro
  879.         _OCEValidRLI
  880.             move.w              #$0337,D0
  881.             dc.w                $AA5C
  882.         EndM
  883.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  884.         IMPORT_CFM_FUNCTION OCEValidRLI
  885.     ENDIF
  886.  
  887. ; *** PackedRLI ***
  888. ;struct PackedRLI is a maximum-sized structure.  Allocate one of
  889. ;these and it will hold any valid packed pathname.
  890. ;
  891.  
  892.  
  893. kRLIMaxBytes                    EQU        1296
  894. PackedRLI                RECORD 0
  895. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  896. data                     ds.b    1296            ; offset: $2 (2)
  897. sizeof                     EQU *                    ; size:   $512 (1298)
  898.                         ENDR
  899. ;struct ProtoPackedRLI is a minimum-sized structure.  Use this
  900. ;for a variable-length packed RLI.
  901. ;
  902.  
  903. ProtoPackedRLI            RECORD 0
  904. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  905. ;  Followed by data 
  906. sizeof                     EQU *                    ; size:   $2 (2)
  907.                         ENDR
  908. ; typedef struct PackedRLI *            PackedRLIPtr
  909.  
  910. ; typedef struct ProtoPackedRLI *        ProtoPackedRLIPtr
  911.  
  912. ;Copy the contents of prli1 to prli2.  prli2Length is the size of prli2, and must
  913. ;be large enough to hold a copy of prli1.  A memFull error will be returned if that
  914. ;is not the case.
  915. ;
  916.  
  917. ;
  918. ; pascal OSErr OCECopyPackedRLI(const PackedRLI *prli1, PackedRLI *prli2, unsigned short prli2Length)
  919. ;
  920.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  921.         Macro
  922.         _OCECopyPackedRLI
  923.             move.w              #$0305,D0
  924.             dc.w                $AA5C
  925.         EndM
  926.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  927.         IMPORT_CFM_FUNCTION OCECopyPackedRLI
  928.     ENDIF
  929.  
  930.  
  931. ;OCEUnpackRLI breaks apart the prli into its components, writing pointers into
  932. ;the rli structure.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE
  933. ;PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  934. ;WITH THE UNPACKED STRUCT AS WELL
  935. ;
  936.  
  937. ;
  938. ; pascal void OCEUnpackRLI(const PackedRLI *prli, RLI *theRLI)
  939. ;
  940.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  941.         Macro
  942.         _OCEUnpackRLI
  943.             move.w              #$0331,D0
  944.             dc.w                $AA5C
  945.         EndM
  946.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  947.         IMPORT_CFM_FUNCTION OCEUnpackRLI
  948.     ENDIF
  949.  
  950.  
  951. ;OCEPackedRLISize computes the number of bytes of memory needed to hold a
  952. ;PackedRLI manufactured from an RLI.  This length
  953. ;includes the length of the length field of PackedRLI, so it
  954. ;is safe to do a NewPtr (OCEPackedRLISize(...)).
  955. ;
  956.  
  957. ;
  958. ; pascal unsigned short OCEPackedRLISize(const RLI *theRLI)
  959. ;
  960.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  961.         Macro
  962.         _OCEPackedRLISize
  963.             move.w              #$032A,D0
  964.             dc.w                $AA5C
  965.         EndM
  966.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  967.         IMPORT_CFM_FUNCTION OCEPackedRLISize
  968.     ENDIF
  969.  
  970.  
  971. ;OCEPackRLI packs the RLI into the storage provided as 'prli'.  prli must be
  972. ;large enough to hold the packed RLI.  A memFull error will be returned if
  973. ;prliLength is too small.
  974. ;
  975.  
  976. ;
  977. ; pascal OSErr OCEPackRLI(const RLI *theRLI, PackedRLI *prli, unsigned short prliLength)
  978. ;
  979.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  980.         Macro
  981.         _OCEPackRLI
  982.             move.w              #$0324,D0
  983.             dc.w                $AA5C
  984.         EndM
  985.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  986.         IMPORT_CFM_FUNCTION OCEPackRLI
  987.     ENDIF
  988.  
  989.  
  990. ;OCEPackedRLIPartsSize computes the number of bytes of memory needed to hold a
  991. ;PackedRLI manufactured from the parts of an RLI.  This length
  992. ;includes the length of the length field of PackedRLI, so it
  993. ;is safe to do a NewPtr (OCEPackedRLIPartsSize(...)).
  994. ;
  995.  
  996. ;
  997. ; pascal unsigned short OCEPackedRLIPartsSize(const DirectoryName *dirName, RStringPtr *parts, unsigned short nParts)
  998. ;
  999.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1000.         Macro
  1001.         _OCEPackedRLIPartsSize
  1002.             move.w              #$0329,D0
  1003.             dc.w                $AA5C
  1004.         EndM
  1005.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1006.         IMPORT_CFM_FUNCTION OCEPackedRLIPartsSize
  1007.     ENDIF
  1008.  
  1009. ;OCEPackRLIParts packs the parts of an RLI into the storage provided as 'prli'.
  1010. ;prli must be large enough to hold the packed RLI.  A memFull error will be returned
  1011. ;if prliLength is too small.
  1012. ;
  1013.  
  1014. ;
  1015. ; pascal OSErr OCEPackRLIParts(const DirectoryName *dirName, const DirDiscriminator *discriminator, DNodeNum dNodeNumber, RStringPtr *parts, unsigned short nParts, PackedRLI *prli, unsigned short prliLength)
  1016. ;
  1017.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1018.         Macro
  1019.         _OCEPackRLIParts
  1020.             move.w              #$0325,D0
  1021.             dc.w                $AA5C
  1022.         EndM
  1023.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1024.         IMPORT_CFM_FUNCTION OCEPackRLIParts
  1025.     ENDIF
  1026.  
  1027. ;Check the equality of two packed prlis.
  1028. ;
  1029.  
  1030. ;
  1031. ; pascal Boolean OCEEqualPackedRLI(const PackedRLI *prli1, const PackedRLI *prli2)
  1032. ;
  1033.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1034.         Macro
  1035.         _OCEEqualPackedRLI
  1036.             move.w              #$0313,D0
  1037.             dc.w                $AA5C
  1038.         EndM
  1039.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1040.         IMPORT_CFM_FUNCTION OCEEqualPackedRLI
  1041.     ENDIF
  1042.  
  1043.  
  1044. ;Check the validity of a packed RLI.  This checks that the catalog name length
  1045. ;is within bounds, and the packed pathname (if specified) is valid.
  1046. ;
  1047.  
  1048. ;
  1049. ; pascal Boolean OCEValidPackedRLI(const PackedRLI *prli)
  1050. ;
  1051.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1052.         Macro
  1053.         _OCEValidPackedRLI
  1054.             move.w              #$0336,D0
  1055.             dc.w                $AA5C
  1056.         EndM
  1057.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1058.         IMPORT_CFM_FUNCTION OCEValidPackedRLI
  1059.     ENDIF
  1060.  
  1061. ;If this packed RLI describes a Personal Catalog, this call will return a pointer
  1062. ;to an alias record that can be used to find the actual file.  Otherwise, it returns nil.
  1063. ;
  1064.  
  1065. ;
  1066. ; pascal AliasPtr OCEExtractAlias(const PackedRLI *prli)
  1067. ;
  1068.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1069.         Macro
  1070.         _OCEExtractAlias
  1071.             move.w              #$0318,D0
  1072.             dc.w                $AA5C
  1073.         EndM
  1074.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1075.         IMPORT_CFM_FUNCTION OCEExtractAlias
  1076.     ENDIF
  1077.  
  1078. ;This call returns a pointer to a packed RLI that represents the "Catalogs" icon, or
  1079. ;the root of all catalogs.  It is used in the CollabPack.
  1080. ;
  1081.  
  1082. ;
  1083. ; pascal const PackedRLI *OCEGetDirectoryRootPackedRLI(void )
  1084. ;
  1085.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1086.         Macro
  1087.         _OCEGetDirectoryRootPackedRLI
  1088.             move.w              #$0346,D0
  1089.             dc.w                $AA5C
  1090.         EndM
  1091.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1092.         IMPORT_CFM_FUNCTION OCEGetDirectoryRootPackedRLI
  1093.     ENDIF
  1094.  
  1095. ; *** LocalRecordID ***
  1096. LocalRecordID            RECORD 0
  1097. cid                         ds        CreationID        ; offset: $0 (0)
  1098. recordName                 ds.l    1                ; offset: $8 (8)
  1099. recordType                 ds.l    1                ; offset: $C (12)
  1100. sizeof                     EQU *                    ; size:   $10 (16)
  1101.                         ENDR
  1102. ; typedef struct LocalRecordID *        LocalRecordIDPtr
  1103.  
  1104. ;  Create a LocalRecordID from a name, type, and CreationID 
  1105. ;
  1106. ; pascal void OCENewLocalRecordID(const RString *recordName, const RString *recordType, const CreationID *cid, LocalRecordID *lRID)
  1107. ;
  1108.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1109.         Macro
  1110.         _OCENewLocalRecordID
  1111.             move.w              #$031E,D0
  1112.             dc.w                $AA5C
  1113.         EndM
  1114.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1115.         IMPORT_CFM_FUNCTION OCENewLocalRecordID
  1116.     ENDIF
  1117.  
  1118. ;Copy LocalRecordID lRID1 to LocalRecordID lRID2.  lRID2 must already contain
  1119. ;pointers to RString structures large enough to hold copies of the corresponding
  1120. ;fields from lRID1.  A memFull error will be returned if that is not the case.
  1121. ;So if you allocate a brand new empty destination, you must at least set up
  1122. ;its length field.
  1123. ;
  1124.  
  1125. ;
  1126. ; pascal OSErr OCECopyLocalRecordID(const LocalRecordID *lRID1, LocalRecordID *lRID2)
  1127. ;
  1128.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1129.         Macro
  1130.         _OCECopyLocalRecordID
  1131.             move.w              #$0302,D0
  1132.             dc.w                $AA5C
  1133.         EndM
  1134.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1135.         IMPORT_CFM_FUNCTION OCECopyLocalRecordID
  1136.     ENDIF
  1137.  
  1138.  
  1139. ;Check the equality of two local RIDs.
  1140. ;
  1141.  
  1142. ;
  1143. ; pascal Boolean OCEEqualLocalRecordID(const LocalRecordID *lRID1, const LocalRecordID *lRID2)
  1144. ;
  1145.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1146.         Macro
  1147.         _OCEEqualLocalRecordID
  1148.             move.w              #$030F,D0
  1149.             dc.w                $AA5C
  1150.         EndM
  1151.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1152.         IMPORT_CFM_FUNCTION OCEEqualLocalRecordID
  1153.     ENDIF
  1154.  
  1155. ; *** ShortRecordID ***
  1156. ShortRecordID            RECORD 0
  1157. rli                         ds.l    1                ; offset: $0 (0)
  1158. cid                         ds        CreationID        ; offset: $4 (4)
  1159. sizeof                     EQU *                    ; size:   $C (12)
  1160.                         ENDR
  1161. ; typedef struct ShortRecordID *        ShortRecordIDPtr
  1162.  
  1163. ;  Create a ShortRecordID from an RLI struct and a CreationID 
  1164. ;
  1165. ; pascal void OCENewShortRecordID(const PackedRLI *theRLI, const CreationID *cid, ShortRecordIDPtr sRID)
  1166. ;
  1167.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1168.         Macro
  1169.         _OCENewShortRecordID
  1170.             move.w              #$0321,D0
  1171.             dc.w                $AA5C
  1172.         EndM
  1173.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1174.         IMPORT_CFM_FUNCTION OCENewShortRecordID
  1175.     ENDIF
  1176.  
  1177.  
  1178. ;Copy ShortRecordID sRID1 to ShortRecordID sRID2.  sRID2 must already contain
  1179. ;pointers to structures large enough to hold copies of the corresponding
  1180. ;fields from sRID1.  A memFull error will be returned if that is not the case.
  1181. ;So if you allocate a brand new empty destination, you must at least set up
  1182. ;its length fields.
  1183. ;
  1184.  
  1185. ;
  1186. ; pascal OSErr OCECopyShortRecordID(const ShortRecordID *sRID1, ShortRecordID *sRID2)
  1187. ;
  1188.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1189.         Macro
  1190.         _OCECopyShortRecordID
  1191.             move.w              #$030A,D0
  1192.             dc.w                $AA5C
  1193.         EndM
  1194.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1195.         IMPORT_CFM_FUNCTION OCECopyShortRecordID
  1196.     ENDIF
  1197.  
  1198.  
  1199. ;Check the equality of two short RIDs.
  1200. ;
  1201.  
  1202. ;
  1203. ; pascal Boolean OCEEqualShortRecordID(const ShortRecordID *sRID1, const ShortRecordID *sRID2)
  1204. ;
  1205.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1206.         Macro
  1207.         _OCEEqualShortRecordID
  1208.             move.w              #$0317,D0
  1209.             dc.w                $AA5C
  1210.         EndM
  1211.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1212.         IMPORT_CFM_FUNCTION OCEEqualShortRecordID
  1213.     ENDIF
  1214.  
  1215. ; *** RecordID ***
  1216. RecordID                RECORD 0
  1217. rli                         ds.l    1                ; offset: $0 (0)        ;  pointer to a packed rli structure 
  1218. local                     ds        LocalRecordID    ; offset: $4 (4)
  1219. sizeof                     EQU *                    ; size:   $14 (20)
  1220.                         ENDR
  1221. ; typedef struct RecordID *                RecordIDPtr
  1222.  
  1223. ;     Create a RecordID from a packed RLI struct and a LocalRecordID.
  1224. ;This doesn't allocate any new space; the RecordID points to the same
  1225. ;packed RLI struct and the same name and type RStrings. 
  1226.  
  1227. ;
  1228. ; pascal void OCENewRecordID(const PackedRLI *theRLI, const LocalRecordID *lRID, RecordID *rid)
  1229. ;
  1230.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1231.         Macro
  1232.         _OCENewRecordID
  1233.             move.w              #$0320,D0
  1234.             dc.w                $AA5C
  1235.         EndM
  1236.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1237.         IMPORT_CFM_FUNCTION OCENewRecordID
  1238.     ENDIF
  1239.  
  1240.  
  1241. ;Copy RecordID RID1 to RecordID RID2.  RID2 must already contain
  1242. ;pointers to structures large enough to hold copies of the corresponding
  1243. ;fields from lRID1.  A memFull error will be returned if that is not the case.
  1244. ;So if you allocate a brand new empty destination, you must at least set up
  1245. ;its length fields.
  1246. ;
  1247.  
  1248. ;
  1249. ; pascal OSErr OCECopyRecordID(const RecordID *rid1, const RecordID *rid2)
  1250. ;
  1251.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1252.         Macro
  1253.         _OCECopyRecordID
  1254.             move.w              #$0309,D0
  1255.             dc.w                $AA5C
  1256.         EndM
  1257.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1258.         IMPORT_CFM_FUNCTION OCECopyRecordID
  1259.     ENDIF
  1260.  
  1261.  
  1262. ;     Check the equality of two RIDs. 
  1263. ;
  1264. ; pascal Boolean OCEEqualRecordID(const RecordID *rid1, const RecordID *rid2)
  1265. ;
  1266.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1267.         Macro
  1268.         _OCEEqualRecordID
  1269.             move.w              #$0314,D0
  1270.             dc.w                $AA5C
  1271.         EndM
  1272.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1273.         IMPORT_CFM_FUNCTION OCEEqualRecordID
  1274.     ENDIF
  1275.  
  1276.  
  1277. ; *** PackedRecordID ***
  1278. ;struct PackedRecordID is a maximum-sized structure.  Allocate one of
  1279. ;these and it will hold any valid packed RecordID.
  1280. ;
  1281.  
  1282.  
  1283. kPackedRecordIDMaxBytes            EQU        1824
  1284. PackedRecordID            RECORD 0
  1285. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1286. data                     ds.b    1824            ; offset: $2 (2)
  1287. sizeof                     EQU *                    ; size:   $722 (1826)
  1288.                         ENDR
  1289. ;struct ProtoPackedRecordID is a minimum-sized structure.  Use this
  1290. ;for a variable-length packed RecordID.
  1291. ;
  1292.  
  1293. ProtoPackedRecordID        RECORD 0
  1294. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1295. ;  Followed by data 
  1296. sizeof                     EQU *                    ; size:   $2 (2)
  1297.                         ENDR
  1298. ; typedef struct PackedRecordID *        PackedRecordIDPtr
  1299.  
  1300. ; typedef struct ProtoPackedRecordID *    ProtoPackedRecordIDPtr
  1301.  
  1302. ;Copy PackedRecordID pRID1 to PackedRecordID pRID2.  pRID2 must already contain
  1303. ;pointers to structures large enough to hold copies of the corresponding
  1304. ;fields from pRID1.  A memFull error will be returned if that is not the case.
  1305. ;pRID2Length is the number of bytes that can be put into pRID2, not counting the
  1306. ;packed RecordID header.
  1307. ;
  1308.  
  1309. ;
  1310. ; pascal OSErr OCECopyPackedRecordID(const PackedRecordID *pRID1, const PackedRecordID *pRID2, unsigned short pRID2Length)
  1311. ;
  1312.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1313.         Macro
  1314.         _OCECopyPackedRecordID
  1315.             move.w              #$0306,D0
  1316.             dc.w                $AA5C
  1317.         EndM
  1318.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1319.         IMPORT_CFM_FUNCTION OCECopyPackedRecordID
  1320.     ENDIF
  1321.  
  1322.  
  1323. ;Create a RecordID from a PackedRecordID.
  1324. ;NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1325. ;OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL
  1326. ;
  1327.  
  1328. ;
  1329. ; pascal void OCEUnpackRecordID(const PackedRecordID *pRID, RecordID *rid)
  1330. ;
  1331.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1332.         Macro
  1333.         _OCEUnpackRecordID
  1334.             move.w              #$0332,D0
  1335.             dc.w                $AA5C
  1336.         EndM
  1337.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1338.         IMPORT_CFM_FUNCTION OCEUnpackRecordID
  1339.     ENDIF
  1340.  
  1341.  
  1342. ;Create a PackedRecordID from a RecordID.  pRID must be large enough to contain
  1343. ;the packed RecordID.  A memFull error will be returned if that is not the case.
  1344. ;packedRecordIDLength is the number of bytes that can be put into pRID, not
  1345. ;counting the header.
  1346. ;
  1347.  
  1348. ;
  1349. ; pascal OSErr OCEPackRecordID(const RecordID *rid, PackedRecordID *pRID, unsigned short packedRecordIDLength)
  1350. ;
  1351.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1352.         Macro
  1353.         _OCEPackRecordID
  1354.             move.w              #$0326,D0
  1355.             dc.w                $AA5C
  1356.         EndM
  1357.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1358.         IMPORT_CFM_FUNCTION OCEPackRecordID
  1359.     ENDIF
  1360.  
  1361.  
  1362. ;Compute the number of bytes of memory needed to hold a RecordID when packed. This
  1363. ;length includes the length of the length field of PackedRecordID, so it
  1364. ;is safe to do a NewPtr (OCEPackedRecordIDSize(...)).
  1365. ;
  1366.  
  1367. ;
  1368. ; pascal unsigned short OCEPackedRecordIDSize(const RecordID *rid)
  1369. ;
  1370.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1371.         Macro
  1372.         _OCEPackedRecordIDSize
  1373.             move.w              #$032B,D0
  1374.             dc.w                $AA5C
  1375.         EndM
  1376.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1377.         IMPORT_CFM_FUNCTION OCEPackedRecordIDSize
  1378.     ENDIF
  1379.  
  1380.  
  1381. ;Check the equality of two packed RIDs.
  1382. ;
  1383.  
  1384. ;
  1385. ; pascal Boolean OCEEqualPackedRecordID(const PackedRecordID *pRID1, const PackedRecordID *pRID2)
  1386. ;
  1387.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1388.         Macro
  1389.         _OCEEqualPackedRecordID
  1390.             move.w              #$0312,D0
  1391.             dc.w                $AA5C
  1392.         EndM
  1393.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1394.         IMPORT_CFM_FUNCTION OCEEqualPackedRecordID
  1395.     ENDIF
  1396.  
  1397.  
  1398. ;  OCEValidPackedRecordID checks the validity of a packed record ID. 
  1399. ;
  1400. ; pascal Boolean OCEValidPackedRecordID(const PackedRecordID *pRID)
  1401. ;
  1402.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1403.         Macro
  1404.         _OCEValidPackedRecordID
  1405.             move.w              #$0335,D0
  1406.             dc.w                $AA5C
  1407.         EndM
  1408.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1409.         IMPORT_CFM_FUNCTION OCEValidPackedRecordID
  1410.     ENDIF
  1411.  
  1412.  
  1413. ; *** DSSpec ***
  1414. DSSpec                    RECORD 0
  1415. entitySpecifier             ds.l    1                ; offset: $0 (0)
  1416. extensionType             ds.l    1                ; offset: $4 (4)
  1417. extensionSize             ds.w    1                ; offset: $8 (8)
  1418. extensionValue             ds.l    1                ; offset: $A (10)
  1419. sizeof                     EQU *                    ; size:   $E (14)
  1420.                         ENDR
  1421. ; typedef struct DSSpec *                DSSpecPtr
  1422.  
  1423. ;struct PackedDSSpec is NOT a maximum-sized structure.  Allocate one of
  1424. ;these and it will hold any valid packed RecordID, but not necessarily any additional
  1425. ;data.
  1426. ;
  1427.  
  1428.  
  1429.  
  1430. kPackedDSSpecMaxBytes            EQU        1832
  1431. PackedDSSpec            RECORD 0
  1432. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1433. data                     ds.b    1832            ; offset: $2 (2)
  1434. sizeof                     EQU *                    ; size:   $72A (1834)
  1435.                         ENDR
  1436. ; typedef struct PackedDSSpec *            PackedDSSpecPtr
  1437.  
  1438. ; typedef PackedDSSpecPtr *                PackedDSSpecHandle
  1439.  
  1440. ;struct ProtoPackedDSSpec is a minimum-sized structure.  Use this
  1441. ;for a variable-length packed DSSpec.
  1442. ;
  1443.  
  1444. ProtoPackedDSSpec        RECORD 0
  1445. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1446. ;  Followed by data 
  1447. sizeof                     EQU *                    ; size:   $2 (2)
  1448.                         ENDR
  1449. ; typedef struct ProtoPackedDSSpec *    ProtoPackedDSSpecPtr
  1450.  
  1451. ;Copy PackedDSSpec pdss1 to PackedDSSpec pdss2.  pdss2 must already contain
  1452. ;pointers to structures large enough to hold copies of the corresponding
  1453. ;fields from pdss1.  A memFull error will be returned if that is not the case.
  1454. ;pdss2Length is the number of bytes that can be put into pdss2, not counting the
  1455. ;packed DSSpec header.
  1456. ;
  1457.  
  1458. ;
  1459. ; pascal OSErr OCECopyPackedDSSpec(const PackedDSSpec *pdss1, const PackedDSSpec *pdss2, unsigned short pdss2Length)
  1460. ;
  1461.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1462.         Macro
  1463.         _OCECopyPackedDSSpec
  1464.             move.w              #$0303,D0
  1465.             dc.w                $AA5C
  1466.         EndM
  1467.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1468.         IMPORT_CFM_FUNCTION OCECopyPackedDSSpec
  1469.     ENDIF
  1470.  
  1471.  
  1472. ;Create a DSSpec from a PackedDSSpec.
  1473. ;NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1474. ;OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL.
  1475. ;A pointer to the extension is returned in dss->extensionValue, and the length of that
  1476. ;extension is returned in dss->extensionSize.  If there is no extension, dss->extensionValue will
  1477. ;be set to nil.  This routine will unpack the RecordID (if any) into rid, unpack the rest
  1478. ;into dss, and set dss->entitySpecifier to rid.
  1479. ;
  1480.  
  1481. ;
  1482. ; pascal void OCEUnpackDSSpec(const PackedDSSpec *pdss, DSSpec *dss, RecordID *rid)
  1483. ;
  1484.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1485.         Macro
  1486.         _OCEUnpackDSSpec
  1487.             move.w              #$032F,D0
  1488.             dc.w                $AA5C
  1489.         EndM
  1490.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1491.         IMPORT_CFM_FUNCTION OCEUnpackDSSpec
  1492.     ENDIF
  1493.  
  1494.  
  1495. ;Create a PackedDSSpec from a DSSpec.  pdss must be large enough to
  1496. ;contain the packed RecordID and any extension.  A memFull error will be returned if that
  1497. ;is not the case.  pdssLength is the number of bytes that can be put into pdss,
  1498. ;not counting the header.
  1499. ;
  1500.  
  1501. ;
  1502. ; pascal OSErr OCEPackDSSpec(const DSSpec *dss, PackedDSSpec *pdss, unsigned short pdssLength)
  1503. ;
  1504.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1505.         Macro
  1506.         _OCEPackDSSpec
  1507.             move.w              #$0322,D0
  1508.             dc.w                $AA5C
  1509.         EndM
  1510.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1511.         IMPORT_CFM_FUNCTION OCEPackDSSpec
  1512.     ENDIF
  1513.  
  1514.  
  1515. ;Compute the number of bytes of memory needed to hold a DSSpec when packed. This
  1516. ;length includes the length of the length field of PackedDSSpec, so it
  1517. ;is safe to do a NewPtr (OCEPackedDSSpecSize(...)).
  1518. ;
  1519.  
  1520. ;
  1521. ; pascal unsigned short OCEPackedDSSpecSize(const DSSpec *dss)
  1522. ;
  1523.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1524.         Macro
  1525.         _OCEPackedDSSpecSize
  1526.             move.w              #$0327,D0
  1527.             dc.w                $AA5C
  1528.         EndM
  1529.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1530.         IMPORT_CFM_FUNCTION OCEPackedDSSpecSize
  1531.     ENDIF
  1532.  
  1533.  
  1534. ;     Check the equality of two DSSpecs.  This compares all fields, even the
  1535. ;extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1536. ;diacrit-insensitive manner. 
  1537.  
  1538. ;
  1539. ; pascal Boolean OCEEqualDSSpec(const DSSpec *pdss1, const DSSpec *pdss2)
  1540. ;
  1541.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1542.         Macro
  1543.         _OCEEqualDSSpec
  1544.             move.w              #$030E,D0
  1545.             dc.w                $AA5C
  1546.         EndM
  1547.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1548.         IMPORT_CFM_FUNCTION OCEEqualDSSpec
  1549.     ENDIF
  1550.  
  1551.  
  1552. ;     Check the equality of two PackedDSSpecs.  This compares all fields, even the
  1553. ;extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1554. ;diacrit-insensitive manner. 
  1555.  
  1556. ;
  1557. ; pascal Boolean OCEEqualPackedDSSpec(const PackedDSSpec *pdss1, const PackedDSSpec *pdss2)
  1558. ;
  1559.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1560.         Macro
  1561.         _OCEEqualPackedDSSpec
  1562.             move.w              #$0310,D0
  1563.             dc.w                $AA5C
  1564.         EndM
  1565.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1566.         IMPORT_CFM_FUNCTION OCEEqualPackedDSSpec
  1567.     ENDIF
  1568.  
  1569.  
  1570. ;Check the validity of a PackedDSSpec.  If extensionType is
  1571. ;'entn', pdss must contain a valid entitySpecifier.  For all other extensionTypes, a nil
  1572. ;entitySpecifier is valid, but if non-nil, it will be checked for validity.  No check
  1573. ;is made on the extension.
  1574. ;
  1575.  
  1576. ;
  1577. ; pascal Boolean OCEValidPackedDSSpec(const PackedDSSpec *pdss)
  1578. ;
  1579.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1580.         Macro
  1581.         _OCEValidPackedDSSpec
  1582.             move.w              #$0333,D0
  1583.             dc.w                $AA5C
  1584.         EndM
  1585.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1586.         IMPORT_CFM_FUNCTION OCEValidPackedDSSpec
  1587.     ENDIF
  1588.  
  1589.  
  1590. ;Return info about a DSSpec.  This routine does not check validity.  If the
  1591. ;DSSpec has no extension, we determine whether it represents the root of all
  1592. ;catalogs, a single catalog, a DNode, or a Record.  Else it is invalid.
  1593. ;If the DSSpec has an extension, we simply return the extension type.
  1594. ;
  1595.  
  1596. ;
  1597. ; pascal OSType OCEGetDSSpecInfo(const DSSpec *spec)
  1598. ;
  1599.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1600.         Macro
  1601.         _OCEGetDSSpecInfo
  1602.             move.w              #$0319,D0
  1603.             dc.w                $AA5C
  1604.         EndM
  1605.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1606.         IMPORT_CFM_FUNCTION OCEGetDSSpecInfo
  1607.     ENDIF
  1608.  
  1609.  
  1610. ;  OCEGetExtensionType returns the extensionType imbedded in the PackedDSSpec. 
  1611. ;
  1612. ; pascal OSType OCEGetExtensionType(const PackedDSSpec *pdss)
  1613. ;
  1614.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1615.         Macro
  1616.         _OCEGetExtensionType
  1617.             move.w              #$031C,D0
  1618.             dc.w                $AA5C
  1619.         EndM
  1620.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1621.         IMPORT_CFM_FUNCTION OCEGetExtensionType
  1622.     ENDIF
  1623.  
  1624. ;OCEStreamPackedDSSpec streams (flattens) a catalog object a little at a time by
  1625. ;calling the DSSpecStreamer routine that you provide.
  1626. ;
  1627.  
  1628. ; typedef DSSpecStreamerUPP             DSSpecStreamer
  1629.  
  1630. ;
  1631. ; pascal OSErr OCEStreamPackedDSSpec(const DSSpec *dss, DSSpecStreamer stream, long userData, unsigned long *actualCount)
  1632. ;
  1633.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1634.         Macro
  1635.         _OCEStreamPackedDSSpec
  1636.             move.w              #$033D,D0
  1637.             dc.w                $AA5C
  1638.         EndM
  1639.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1640.         IMPORT_CFM_FUNCTION OCEStreamPackedDSSpec
  1641.     ENDIF
  1642.  
  1643. ; *** AttributeType ***
  1644. ;For the record, an AttributeType is an RString with a smaller maximum size.
  1645. ;I don't just typedef it to an RString, because I want the definition of the AttributeType
  1646. ;struct to contain the max length, because I need to include it in the Attribute struct
  1647. ;below.  But it should be possible to typecast any AttributeType to an RString and use
  1648. ;all the RString utilities on it.
  1649. ;
  1650.  
  1651. AttributeType            RECORD 0
  1652. charSet                     ds.w    1                ; offset: $0 (0)
  1653. dataLength                 ds.w    1                ; offset: $2 (2)
  1654. body                     ds.b    32                ; offset: $4 (4)        ;  always fixed at the max size 
  1655. sizeof                     EQU *                    ; size:   $24 (36)
  1656.                         ENDR
  1657. ; typedef struct AttributeType *        AttributeTypePtr
  1658.  
  1659. ;  Miscellaneous defines:  (these cannot be made into enums) 
  1660.  
  1661. kMinPackedRStringLength            EQU        4
  1662.  
  1663. kMinPackedRLISize                EQU        20
  1664. ; *** AttributeValue ***
  1665. ;  same class as is used in AppleEvents 
  1666. ; typedef DescType                         AttributeTag
  1667.  
  1668. AttributeValue            RECORD 0
  1669. tag                         ds.l    1                ; offset: $0 (0)
  1670. dataLength                 ds.l    1                ; offset: $4 (4)
  1671. bytes                     ds.l    1                ; offset: $8 (8)
  1672. sizeof                     EQU *                    ; size:   $C (12)
  1673.                         ENDR
  1674. ; typedef struct AttributeValue *        AttributeValuePtr
  1675.  
  1676. ; *** Attribute ***
  1677. Attribute                RECORD 0
  1678. attributeType             ds        AttributeType    ; offset: $0 (0)
  1679. cid                         ds        AttributeCreationID ; offset: $24 (36)
  1680. value                     ds        AttributeValue ; offset: $2C (44)
  1681. sizeof                     EQU *                    ; size:   $38 (56)
  1682.                         ENDR
  1683. ; typedef struct Attribute *            AttributePtr
  1684.  
  1685. ;
  1686. ; pascal RString *OCEGetIndRecordType(OCERecordTypeIndex stringIndex)
  1687. ;
  1688.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1689.         Macro
  1690.         _OCEGetIndRecordType
  1691.             move.w              #$031B,D0
  1692.             dc.w                $AA5C
  1693.         EndM
  1694.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1695.         IMPORT_CFM_FUNCTION OCEGetIndRecordType
  1696.     ENDIF
  1697.  
  1698. ;
  1699. ; pascal AttributeType *OCEGetIndAttributeType(OCEAttributeTypeIndex stringIndex)
  1700. ;
  1701.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1702.         Macro
  1703.         _OCEGetIndAttributeType
  1704.             move.w              #$031A,D0
  1705.             dc.w                $AA5C
  1706.         EndM
  1707.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1708.         IMPORT_CFM_FUNCTION OCEGetIndAttributeType
  1709.     ENDIF
  1710.  
  1711.  
  1712. _oceTBDispatch                    EQU        $AA5E
  1713. ; ****************************************************************************************
  1714. ;   PLEASE NOTE! ROUTINES HAVE MOVED TO THIS HEADER!
  1715. ;   OCESizePackedRecipient, OCEPackRecipient, OCEUnpackRecipient, OCEStreamRecipient,
  1716. ;   OCEGetRecipientType, and OCESetRecipientType have moved to the OCE header file.
  1717. ;   The OCEMessaging header includes the OCE header, so no changes to your code are
  1718. ;   required.
  1719. ;
  1720. ;***************************************************************************************
  1721.  
  1722. OCERecipient            RECORD 0
  1723. f                         ds        DSSpec
  1724. sizeof                     EQU *                    ; size:   $E (14)
  1725.                         ENDR
  1726.  
  1727.  
  1728.  
  1729. kOCESizePackedRecipient            EQU        830
  1730. kOCEPackRecipient                EQU        831
  1731. kOCEUnpackRecipient                EQU        832
  1732. kOCEStreamRecipient                EQU        833
  1733. kOCEGetRecipientType            EQU        834
  1734. kOCESetRecipientType            EQU        835
  1735. ;Compute the space that a OCERecipient would take if it were in packed
  1736. ;form.  [Note: does NOT even pad extensionSize, so you may get an odd #back out]
  1737. ;Safe to pass dereferenced handle(s).
  1738. ;
  1739.  
  1740. ;
  1741. ; pascal unsigned short OCESizePackedRecipient(const OCERecipient *rcpt)
  1742. ;
  1743.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1744.         Macro
  1745.         _OCESizePackedRecipient
  1746.             move.w              #$033E,D0
  1747.             dc.w                $AA5C
  1748.         EndM
  1749.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1750.         IMPORT_CFM_FUNCTION OCESizePackedRecipient
  1751.     ENDIF
  1752.  
  1753.  
  1754. ;Take an OCERecipient (scatter) and (gather) stream into the specified
  1755. ;buffer.  It is assumed that there is sufficient space in the buffer (that is
  1756. ;OCESizePackedRecipient).  Safe to pass dereferenced handle(s).
  1757. ;
  1758.  
  1759. ;
  1760. ; pascal unsigned short OCEPackRecipient(const OCERecipient *rcpt, void *buffer)
  1761. ;
  1762.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1763.         Macro
  1764.         _OCEPackRecipient
  1765.             move.w              #$033F,D0
  1766.             dc.w                $AA5C
  1767.         EndM
  1768.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1769.         IMPORT_CFM_FUNCTION OCEPackRecipient
  1770.     ENDIF
  1771.  
  1772. ;Take a packed OCERecipient and cast a the OCERecipient frame over it. Returns
  1773. ;amBadDestId if it doesn't look like an OCERecipient. Safe to pass dereferenced
  1774. ;handle(s).
  1775. ;
  1776.  
  1777. ;
  1778. ; pascal OSErr OCEUnpackRecipient(const void *buffer, OCERecipient *rcpt, RecordID *entitySpecifier)
  1779. ;
  1780.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1781.         Macro
  1782.         _OCEUnpackRecipient
  1783.             move.w              #$0340,D0
  1784.             dc.w                $AA5C
  1785.         EndM
  1786.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1787.         IMPORT_CFM_FUNCTION OCEUnpackRecipient
  1788.     ENDIF
  1789.  
  1790. ;Take an OCERecipient (scatter) and (gather) stream using the specified
  1791. ;function.  Safe to pass dereferenced handle(s).  If streamer function returns
  1792. ;OCEError OCEStreamRecipient stops execution and passes the error back to the caller
  1793. ;
  1794.  
  1795. ; typedef OCERecipientStreamerUPP         OCERecipientStreamer
  1796.  
  1797. ;
  1798. ; pascal OSErr OCEStreamRecipient(const OCERecipient *rcpt, OCERecipientStreamer stream, long userData, unsigned long *actualCount)
  1799. ;
  1800.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1801.         Macro
  1802.         _OCEStreamRecipient
  1803.             move.w              #$0341,D0
  1804.             dc.w                $AA5C
  1805.         EndM
  1806.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1807.         IMPORT_CFM_FUNCTION OCEStreamRecipient
  1808.     ENDIF
  1809.  
  1810. ;  Get the OCERecipient's extensionType. Safe to pass dereferenced handle(s).
  1811. ;
  1812. ; pascal OSType OCEGetRecipientType(const CreationID *cid)
  1813. ;
  1814.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1815.         Macro
  1816.         _OCEGetRecipientType
  1817.             move.w              #$0342,D0
  1818.             dc.w                $AA5C
  1819.         EndM
  1820.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1821.         IMPORT_CFM_FUNCTION OCEGetRecipientType
  1822.     ENDIF
  1823.  
  1824.  
  1825. ;Set the OCERecipient's extensionType in the specified cid.  (Note: we do NOT
  1826. ;check for a nil pointer).  If the extensionType is 'entn', the cid is assumed
  1827. ;to be "valid" and is not touched.  Note: to properly handle non 'entn''s this
  1828. ;routine must and will zero the high long (source) of the cid! Safe to pass
  1829. ;dereferenced handle(s).
  1830. ;
  1831.  
  1832. ;
  1833. ; pascal void OCESetRecipientType(OSType extensionType, CreationID *cid)
  1834. ;
  1835.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1836.         Macro
  1837.         _OCESetRecipientType
  1838.             move.w              #$0343,D0
  1839.             dc.w                $AA5C
  1840.         EndM
  1841.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1842.         IMPORT_CFM_FUNCTION OCESetRecipientType
  1843.     ENDIF
  1844.  
  1845. ; ****************************************************************************************
  1846. ;   PLEASE NOTE! ROUTINES HAVE MOVED TO THIS HEADER!
  1847. ;   OCEGetAccessControlDSSpec and its corresponding data type and constants have
  1848. ;   moved to the OCE header from OCEAuthDir. The OCEAuthDir header includes the OCE
  1849. ;   header, so no changes to your code are required.
  1850. ;   
  1851. ;***************************************************************************************
  1852.  
  1853. ;  access categories bit numbers 
  1854.  
  1855. kThisRecordOwnerBit                EQU        0
  1856. kFriendsBit                        EQU        1
  1857. kAuthenticatedInDNodeBit        EQU        2
  1858. kAuthenticatedInDirectoryBit    EQU        3
  1859. kGuestBit                        EQU        4
  1860. kMeBit                            EQU        5
  1861. ;  Values of CategoryMask 
  1862.  
  1863. kThisRecordOwnerMask            EQU        1
  1864. kFriendsMask                    EQU        2
  1865. kAuthenticatedInDNodeMask        EQU        4
  1866. kAuthenticatedInDirectoryMask    EQU        8
  1867. kGuestMask                        EQU        16
  1868. kMeMask                            EQU        32
  1869. ; typedef unsigned long                 CategoryMask
  1870.  
  1871. ;pass kThisRecordOwnerMask, kFriendsMask, kAuthenticatedInDNodeMask, kAuthenticatedInDirectoryMask,
  1872. ;kGuestMask, or kMeMask to this routine, and it will return a pointer to a
  1873. ;DSSpec that can be used in the Get or Set Access Controls calls.
  1874. ;
  1875.  
  1876. ;
  1877. ; pascal DSSpec *OCEGetAccessControlDSSpec(CategoryMask categoryBitMask)
  1878. ;
  1879.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1880.         Macro
  1881.         _OCEGetAccessControlDSSpec
  1882.             move.w              #$0345,D0
  1883.             dc.w                $AA5C
  1884.         EndM
  1885.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1886.         IMPORT_CFM_FUNCTION OCEGetAccessControlDSSpec
  1887.     ENDIF
  1888.  
  1889.  
  1890.  
  1891.  
  1892.     ENDIF ; __OCE__ 
  1893.  
  1894.